#pragma GCC optimize(2, "Ofast", "inline")
#include <iostream>
#include <vector>
#include <map>
#include <cmath>
#include <set>
#include <queue>
#include <stack>
#include <list>
#include <unordered_map>
#include <algorithm>
#include <bitset>
#include <string>
#define endl '\n'
#define int long long
#define pii pair<int, int>
using namespace std;

const int BASE = 1LL << 60; // 使用2^60作为基数，防止溢出

struct i256
{
    // 用4个longlong来模拟一个int256
    int a, b, c, d; // 从高位到低位，a是最高位
    
    i256() { a = 0; b = 0; c = 0; d = 0; }
    
    i256(int val) { a = 0; b = 0; c = 0; d = val; }
    
    i256(string s)
    {
        a = b = c = d = 0;
        // 处理二进制字符串
        if (s.size() > 2 && s[0] == '0' && (s[1] == 'b' || s[1] == 'B')) {
            s = s.substr(2);
            while (s.size() < 256) s = "0" + s;
            for (int i = 0; i < 64; i++) if (s[i] == '1') a |= (1LL << (63 - i));
            for (int i = 0; i < 64; i++) if (s[i + 64] == '1') b |= (1LL << (63 - i));
            for (int i = 0; i < 64; i++) if (s[i + 128] == '1') c |= (1LL << (63 - i));
            for (int i = 0; i < 64; i++) if (s[i + 192] == '1') d |= (1LL << (63 - i));
            return;
        }
        
        // 处理十进制字符串
        i256 result;
        i256 power(1);
        
        for (int i = s.size() - 1; i >= 0; i--) {
            if (s[i] < '0' || s[i] > '9') continue;
            int digit = s[i] - '0';
            if (digit > 0) {
                i256 term = power;
                term = term * digit;
                result = result + term;
            }
            power = power * 10;
        }
        
        *this = result;
    }
    
    i256(const int a, const int b, const int c, const int d) : a(a), b(b), c(c), d(d) {}

    // 加法运算
    i256 operator+(const i256& other) const {
        i256 result;
        int carry = 0;
        
        // 从低位到高位依次相加
        unsigned long long sum = (unsigned long long)d + other.d;
        result.d = sum % BASE;
        carry = sum / BASE;
        
        sum = (unsigned long long)c + other.c + carry;
        result.c = sum % BASE;
        carry = sum / BASE;
        
        sum = (unsigned long long)b + other.b + carry;
        result.b = sum % BASE;
        carry = sum / BASE;
        
        result.a = a + other.a + carry;
        
        return result;
    }
    
    // 减法运算
    i256 operator-(const i256& other) const {
        i256 result;
        int borrow = 0;
        
        // 从低位到高位依次相减
        long long diff = (long long)d - other.d - borrow;
        if (diff < 0) {
            diff += BASE;
            borrow = 1;
        } else {
            borrow = 0;
        }
        result.d = diff;
        
        diff = (long long)c - other.c - borrow;
        if (diff < 0) {
            diff += BASE;
            borrow = 1;
        } else {
            borrow = 0;
        }
        result.c = diff;
        
        diff = (long long)b - other.b - borrow;
        if (diff < 0) {
            diff += BASE;
            borrow = 1;
        } else {
            borrow = 0;
        }
        result.b = diff;
        
        result.a = a - other.a - borrow;
        
        return result;
    }
    
    // 乘法运算（简化版，仅支持与小整数相乘）
    i256 operator*(int val) const {
        i256 result;
        unsigned long long carry = 0;
        
        unsigned long long prod = (unsigned long long)d * val + carry;
        result.d = prod % BASE;
        carry = prod / BASE;
        
        prod = (unsigned long long)c * val + carry;
        result.c = prod % BASE;
        carry = prod / BASE;
        
        prod = (unsigned long long)b * val + carry;
        result.b = prod % BASE;
        carry = prod / BASE;
        
        result.a = a * val + carry;
        
        return result;
    }
    
    // 完整的乘法运算
    i256 operator*(const i256& other) const {
        i256 result;
        
        // 简单实现，效率较低但容易理解
        for (int i = 0; i < 256; i++) {
            if (getBit(i)) {
                i256 temp = other;
                temp = temp << i;
                result = result + temp;
            }
        }
        
        return result;
    }
    
    // 左移运算
    i256 operator<<(int shift) const {
        if (shift >= 256) return i256();
        if (shift == 0) return *this;
        
        i256 result;
        
        // 处理整数部分的移位
        int block_shift = shift / 64;
        int bit_shift = shift % 64;
        
        if (block_shift == 0) {
            if (bit_shift == 0) return *this;
            
            // 处理位移动
            if (bit_shift > 0) {
                result.a = (a << bit_shift) | (b >> (64 - bit_shift));
                result.b = (b << bit_shift) | (c >> (64 - bit_shift));
                result.c = (c << bit_shift) | (d >> (64 - bit_shift));
                result.d = d << bit_shift;
            }
        } else if (block_shift == 1) {
            result.a = b;
            result.b = c;
            result.c = d;
            result.d = 0;
            
            if (bit_shift > 0) {
                result = result << bit_shift;
            }
        } else if (block_shift == 2) {
            result.a = c;
            result.b = d;
            result.c = 0;
            result.d = 0;
            
            if (bit_shift > 0) {
                result = result << bit_shift;
            }
        } else if (block_shift == 3) {
            result.a = d;
            result.b = 0;
            result.c = 0;
            result.d = 0;
            
            if (bit_shift > 0) {
                result = result << bit_shift;
            }
        }
        
        return result;
    }
    
    // 右移运算
    i256 operator>>(int shift) const {
        if (shift >= 256) return i256();
        if (shift == 0) return *this;
        
        i256 result;
        
        // 处理整数部分的移位
        int block_shift = shift / 64;
        int bit_shift = shift % 64;
        
        if (block_shift == 0) {
            if (bit_shift == 0) return *this;
            
            // 处理位移动
            if (bit_shift > 0) {
                result.d = (d >> bit_shift) | (c << (64 - bit_shift));
                result.c = (c >> bit_shift) | (b << (64 - bit_shift));
                result.b = (b >> bit_shift) | (a << (64 - bit_shift));
                result.a = a >> bit_shift;
            }
        } else if (block_shift == 1) {
            result.d = c;
            result.c = b;
            result.b = a;
            result.a = 0;
            
            if (bit_shift > 0) {
                result = result >> bit_shift;
            }
        } else if (block_shift == 2) {
            result.d = b;
            result.c = a;
            result.b = 0;
            result.a = 0;
            
            if (bit_shift > 0) {
                result = result >> bit_shift;
            }
        } else if (block_shift == 3) {
            result.d = a;
            result.c = 0;
            result.b = 0;
            result.a = 0;
            
            if (bit_shift > 0) {
                result = result >> bit_shift;
            }
        }
        
        return result;
    }
    
    // 获取指定位的值
    bool getBit(int pos) const {
        if (pos < 0 || pos >= 256) return false;
        
        if (pos < 64) {
            return (d & (1LL << pos)) != 0;
        } else if (pos < 128) {
            return (c & (1LL << (pos - 64))) != 0;
        } else if (pos < 192) {
            return (b & (1LL << (pos - 128))) != 0;
        } else {
            return (a & (1LL << (pos - 192))) != 0;
        }
    }
    
    // 比较运算符
    bool operator==(const i256& other) const {
        return a == other.a && b == other.b && c == other.c && d == other.d;
    }
    
    bool operator!=(const i256& other) const {
        return !(*this == other);
    }
    
    bool operator<(const i256& other) const {
        if (a != other.a) return a < other.a;
        if (b != other.b) return b < other.b;
        if (c != other.c) return c < other.c;
        return d < other.d;
    }
    
    bool operator>(const i256& other) const {
        return other < *this;
    }
    
    bool operator<=(const i256& other) const {
        return !(other < *this);
    }
    
    bool operator>=(const i256& other) const {
        return !(*this < other);
    }
    
    // 输出运算符
    friend ostream& operator<<(ostream& os, const i256& x)
    {
        // 如果是0，直接输出0
        if (x.a == 0 && x.b == 0 && x.c == 0 && x.d == 0) {
            return os << "0";
        }
        
        // 转换为十进制字符串
        string result;
        i256 temp = x;
        while (!(temp.a == 0 && temp.b == 0 && temp.c == 0 && temp.d == 0)) {
            int remainder = 0;
            i256 quotient;
            
            // 除以10
            for (int i = 0; i < 64; i++) {
                remainder = (remainder << 1) | ((temp.a >> (63 - i)) & 1);
                quotient.a = (quotient.a << 1) | (remainder / 10);
                remainder %= 10;
            }
            
            for (int i = 0; i < 64; i++) {
                remainder = (remainder << 1) | ((temp.b >> (63 - i)) & 1);
                quotient.b = (quotient.b << 1) | (remainder / 10);
                remainder %= 10;
            }
            
            for (int i = 0; i < 64; i++) {
                remainder = (remainder << 1) | ((temp.c >> (63 - i)) & 1);
                quotient.c = (quotient.c << 1) | (remainder / 10);
                remainder %= 10;
            }
            
            for (int i = 0; i < 64; i++) {
                remainder = (remainder << 1) | ((temp.d >> (63 - i)) & 1);
                quotient.d = (quotient.d << 1) | (remainder / 10);
                remainder %= 10;
            }
            
            result = char('0' + remainder) + result;
            temp = quotient;
        }
        
        return os << result;
    }
    
    // 输入运算符
    friend istream& operator>>(istream& is, i256& x)
    {
        string s; is >> s;
        x = i256(s);
        return is;
    }
};
// 已知

// 未知

signed main()
{
    cin.tie(0)->sync_with_stdio(0);
    cout.tie(0);
    i256 s;
    cin>>s;
    cout << s << endl;



    return 0;
}